Geologia TypeScript: Implementazione di Tipi per le Scienze della Terra per un Pubblico Globale

            
// Enum per ampie categorie di roccia
export enum RockCategory {
  Igneous = "Igneous",
  Sedimentary = "Sedimentary",
  Metamorphic = "Metamorphic",
  Unclassified = "Unclassified"
}

// Interfaccia per una specifica composizione minerale
export interface MineralComposition {
  mineral: string; // e.g., "Quartz", "Feldspar", "Mica"
  percentage: number; // Percentuale in volume o peso
}

// Interfaccia per un descrittore litologico generale
export interface LithologyDescriptor {
  name: string; // e.g., "Granite", "Sandstone", "Schist"
  category: RockCategory;
  description?: string; // Descrizione dettagliata opzionale
  primaryMinerals?: MineralComposition[];
  secondaryMinerals?: MineralComposition[];
  grainSize?: "Fine" | "Medium" | "Coarse"; // e.g., per rocce sedimentarie
  porosity?: number; // Percentuale, per rocce serbatoio
  permeability?: number; // e.g., in mD (millidarcy)
}

// Esempio di utilizzo:
const graniteLithology: LithologyDescriptor = {
  name: "Biotite Granite",
  category: RockCategory.Igneous,
  description: "A coarse-grained igneous rock rich in quartz, feldspar, and biotite mica.",
  primaryMinerals: [
    { mineral: "Quartz", percentage: 30 },
    { mineral: "Orthoclase Feldspar", percentage: 40 },
    { mineral: "Plagioclase Feldspar", percentage: 15 }
  ],
  secondaryMinerals: [
    { mineral: "Biotite", percentage: 10 },
    { mineral: "Muscovite", percentage: 5 }
  ],
  grainSize: "Coarse"
};

            

              
                Copy
              
            
          

            
// Enum per sistemi cristallini
export enum CrystalSystem {
  Cubic = "Cubic",
  Tetragonal = "Tetragonal",
  Orthorhombic = "Orthorhombic",
  Monoclinic = "Monoclinic",
  Triclinic = "Triclinic",
  Hexagonal = "Hexagonal",
  Trigonal = "Trigonal"
}

// Interfaccia per uno specifico minerale
export interface Mineral {
  name: string; // e.g., "Quartz", "Calcite", "Pyrite"
  chemicalFormula: string; // e.g., "SiO2", "CaCO3", "FeS2"
  mohsHardness: number;
  density: number; // g/cm³
  color?: string[]; // Array di colori comuni
  streak?: string;
  luster?: "Vitreous" | "Metallic" | "Dull" | "Resinous";
  crystalSystem: CrystalSystem;
  formationEnvironment?: string[]; // e.g., "Hydrothermal", "Igneous", "Metamorphic"
}

// Esempio di utilizzo:
const quartzMineral: Mineral = {
  name: "Quartz",
  chemicalFormula: "SiO2",
  mohsHardness: 7,
  density: 2.65,
  color: ["Colorless", "White", "Pink", "Purple", "Brown", "Black"],
  luster: "Vitreous",
  crystalSystem: CrystalSystem.Hexagonal,
  formationEnvironment: ["Igneous", "Metamorphic", "Sedimentary"]
};

            

              
                Copy
              
            
          

            
// Enum per tipi di faglia
export enum FaultType {
  Normal = "Normal",
  Reverse = "Reverse",
  Thrust = "Thrust",
  StrikeSlip = "Strike-Slip",
  ObliqueSlip = "Oblique-Slip",
  Unknown = "Unknown"
}

// Interfaccia per un segmento di faglia
export interface FaultSegment {
  id: string; // Identificatore univoco
  name?: string; // Nome opzionale (e.g., "San Andreas Fault")
  type: FaultType;
  dipAngle?: number; // Gradi dall'orizzontale
  dipDirection?: number; // Gradi da Nord (0-360)
  strike?: number; // Gradi da Nord (0-360)
  rake?: number; // Angolo di scivolamento sul piano di faglia (gradi)
  length?: number; // Chilometri
  displacement?: number; // Metri o chilometri
  associatedStructures?: string[]; // e.g., "drag folds", "shatter zones"
}

// Interfaccia per una piega
export interface Fold {
  id: string;
  name?: string;
  axisTrend?: number; // Gradi da Nord
  axisPlunge?: number; // Gradi dall'orizzontale
  hingeLine?: string;
  limbs?: Array<{ side: "Upward" | "Downward" | "Left" | "Right", dipAngle?: number, dipDirection?: number }>;
  foldType?: "Anticline" | "Syncline" | "Monocline" | "Chevron" | "Box" | "Concentric";
}

// Esempio di utilizzo:
const majorFault: FaultSegment = {
  id: "FA-101",
  name: "East African Rift Fault",
  type: FaultType.Normal,
  dipAngle: 60,
  dipDirection: 90, // East
  strike: 0,
  length: 1000,
  displacement: 5000 // metri
};

            

              
                Copy
              
            
          

            
// Enum per metodi di datazione
export enum DatingMethod {
  Radiometric = "Radiometric",
  Paleomagnetic = "Paleomagnetic",
  Biostratigraphic = "Biostratigraphic",
  Archaeomagnetic = "Archaeomagnetic"
}

// Interfaccia per un risultato di datazione radiometrica
export interface RadiometricDate {
  method: DatingMethod.Radiometric;
  isotopeSystem: string; // e.g., "U-Pb", "K-Ar", "Ar-Ar", "Rb-Sr"
  age: number; // Età in Ma (Mega-annum)
  uncertainty: number; // Incertezza in Ma
  sampleDescription: string;
}

// Interfaccia per un'unità stratigrafica
export interface StratigraphicUnit {
  id: string;
  name: string; // e.g., "Green River Formation"
  ageRange: {
    minAge: number; // Ma
    maxAge: number; // Ma
    description?: string; // e.g., "Early to Middle Eocene"
  };
  lithology?: LithologyDescriptor;
  thickness?: number; // Metri
  depositionalEnvironment?: string;
  contactWithLowerUnit?: string;
  contactWithUpperUnit?: string;
}

// Esempio di utilizzo:
const zir dating: RadiometricDate = {
  method: DatingMethod.Radiometric,
  isotopeSystem: "U-Pb",
  age: 50.2,
  uncertainty: 0.5,
  sampleDescription: "Zircon from felsic ignimbrite, sample ID: ZRB-123"
};

const formation: StratigraphicUnit = {
  id: "SU-456",
  name: "Kimmeridge Clay Formation",
  ageRange: {
    minAge: 157.3,
    maxAge: 152.1,
    description: "Late Jurassic (Kimmeridgian)"
  },
  lithology: {
    name: "Shale",
    category: RockCategory.Sedimentary,
    grainSize: "Fine"
  },
  thickness: 400
};

            

              
                Copy
              
            
          

            
// Interfaccia per un singolo valore di saggio geochimico
export interface AssayValue {
  element: string; // e.g., "Au", "Ag", "Cu", "Fe2O3"
  value: number;
  unit: string; // e.g., "ppm", "ppb", "%", "g/t"
  detectionLimit?: number; // Se applicabile
  isBelowDetectionLimit?: boolean;
}

// Interfaccia per un attributo di traccia sismica
export interface SeismicAttribute {
  name: string; // e.g., "Amplitude", "Frequency", "RMS Amplitude"
  value: number;
  unit: string; // e.g., "Pa", "Hz", "V^2*s"
}

// Interfaccia per un punto di campionamento del foro di trivellazione
export interface SamplePoint {
   boreholeId: string;
  depthFrom: number; // Metri
  depthTo: number; // Metri
  lithology?: LithologyDescriptor;
  assays?: AssayValue[];
  seismicAttributes?: SeismicAttribute[];
  photographicReference?: string; // URL all'immagine
}

// Esempio di utilizzo:
const goldAssay: AssayValue = {
  element: "Au",
  value: 5.2,
  unit: "g/t"
};

const copperAssay: AssayValue = {
  element: "Cu",
  value: 2500,
  unit: "ppm"
};

const sampleFromMagellan: SamplePoint = {
  boreholeId: "BH-XYZ-007",
  depthFrom: 150.5,
  depthTo: 152.0,
  assays: [goldAssay, copperAssay],
  lithology: {
    name: "Sulfide-bearing Andesite",
    category: RockCategory.Igneous,
    primaryMinerals: [
      { mineral: "Plagioclase", percentage: 50 },
      { mineral: "Amphibole", percentage: 30 }
    ],
    secondaryMinerals: [
      { mineral: "Chalcopyrite", percentage: 5 },
      { mineral: "Pyrite", percentage: 2 }
    ]
  }
};

            

              
                Copy
              
            
          

            
// Enum per datum geodetici comuni
export enum GeodeticDatum {
  WGS84 = "WGS84",
  NAD83 = "NAD83",
  ETRS89 = "ETRS89"
}

// Interfaccia per una coordinata geografica
export interface GeographicCoordinate {
  latitude: number; // Gradi decimali
  longitude: number; // Gradi decimali
  datum: GeodeticDatum;
}

// Enum per proiezioni cartografiche comuni
export enum ProjectionType {
  Mercator = "Mercator",
  UTM = "UTM",
  LambertConformalConic = "LambertConformalConic",
  AlbersEqualArea = "AlbersEqualArea"
}

// Interfaccia per una coordinata proiettata
export interface ProjectedCoordinate {
  x: number; // Est
  y: number; // Nord
  projection: ProjectionType;
  datum: GeodeticDatum;
  zone?: number; // Per UTM
  centralMeridian?: number; // Per altre proiezioni
  standardParallel?: number; // Per altre proiezioni
}

// Esempio di utilizzo:
const pointInKyoto: GeographicCoordinate = {
  latitude: 35.0116,
  longitude: 135.7681,
  datum: GeodeticDatum.WGS84
};

// Si supponga una funzione che converta le coordinate geografiche in proiettate
function projectWGS84ToUTM(coord: GeographicCoordinate, utmZone: number): ProjectedCoordinate {
  // ... la logica di proiezione effettiva andrebbe qui ...
  console.log(`Projecting ${coord.latitude}, ${coord.longitude} to UTM Zone ${utmZone}`);
  return { x: 123456.78, y: 3876543.21, projection: ProjectionType.UTM, datum: GeodeticDatum.WGS84, zone: utmZone };
}

const projectedPoint: ProjectedCoordinate = projectWGS84ToUTM(pointInKyoto, 54); // Zona UTM 54 per il Giappone

            

              
                Copy
              
            
          

            
// Interfaccia semplificata per la feature GeoJSON
export interface GeoJsonFeature {
  type: "Feature";
  geometry: {
    type: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection";
    coordinates: any; // Tipo ricorsivo complesso per le coordinate
  };
  properties: { [key: string]: any };
}

// Interfaccia per una feature geologica, che estende GeoJSON
export interface GeologicalFeature extends GeoJsonFeature {
  properties: {
    name: string;
    type: "Fault" | "StratigraphicBoundary" | "Outcrop" | "MineralDeposit";
    description?: string;
    // Aggiungi qui le proprietà specifiche della geologia
    associatedLithology?: string;
    faultType?: FaultType;
    ageMa?: number;
    mineralCommodity?: string;
  };
}

// Esempio di utilizzo:
const faultGeoJson: GeologicalFeature = {
  type: "Feature",
  geometry: {
    type: "LineString",
    coordinates: [
      [139.6917, 35.6895], // Tokyo
      [139.7528, 35.6852]  // Palazzo Imperiale
    ]
  },
  properties: {
    name: "Tokyo Fault Segment A",
    type: "Fault",
    description: "A major thrust fault underlying the metropolitan area.",
    faultType: FaultType.Thrust
  }
};

            

              
                Copy
              
            
          

            
// Interfaccia per un singolo punto dati in una serie temporale
export interface TimeSeriesPoint {
  timestamp: Date; // Oggetto Date standard di JavaScript
  value: number;
  qualityFlag?: "Good" | "Suspect" | "Bad" | "Estimated";
}

// Interfaccia per un dataset di serie temporale
export interface TimeSeriesDataset {
  id: string;
  name: string;
  units: string;
  description?: string;
  data: TimeSeriesPoint[];
  metadata?: { [key: string]: any }; // Contesto aggiuntivo come ID stazione, posizione, ecc.
}

// Esempio di utilizzo:
const temperatureData: TimeSeriesDataset = {
  id: "temp-tokyo-station-45",
  name: "Daily Average Temperature",
  units: "°C",
  data: [
    { timestamp: new Date("2023-01-01"), value: 5.2 },
    { timestamp: new Date("2023-01-02"), value: 4.8, qualityFlag: "Good" },
    { timestamp: new Date("2023-01-03"), value: 3.9, qualityFlag: "Suspect" },
    // ... altri punti dati
  ],
  metadata: {
    stationId: "45",
    location: { latitude: 35.6895, longitude: 139.6917 }
  }
};

            

              
                Copy
              
            
          

            
// Interfaccia per una cella di griglia in 3D
export interface GridCell3D {
  xIndex: number;
  yIndex: number;
  zIndex: number;
  // Proprietà che possono variare per cella
  porosity?: number;
  permeability?: number;
  density?: number;
  temperature?: number;
  pressure?: number;
}

// Interfaccia per le condizioni al contorno di simulazione
export interface BoundaryCondition {
  type: "Dirichlet" | "Neumann" | "Robin";
  value: number; // O una funzione per condizioni variabili nel tempo
  boundaryName: "top" | "bottom" | "north" | "south" | "east" | "west";
}

// Interfaccia per una configurazione di simulazione
export interface SimulationSetup {
  name: string;
  modelDescription: string;
  gridDimensions: { nx: number; ny: number; nz: number };
  spatialResolution: { dx: number; dy: number; dz: number }; // Metri
  timeStep: number; // Secondi
  totalSimulationTime: number; // Secondi
  boundaryConditions: BoundaryCondition[];
  initialConditions?: { [key: string]: number | number[] }; // e.g., mappa della pressione iniziale
  physicsParameters: {
    viscosity?: number;
    thermalConductivity?: number;
    rockCompressibility?: number;
  };
}

// Esempio di utilizzo:
const reservoirSimulation: SimulationSetup = {
  name: "OilReservoirFlow",
  modelDescription: "Simulates fluid flow in a porous medium.",
  gridDimensions: { nx: 100, ny: 100, nz: 50 },
  spatialResolution: { dx: 10, dy: 10, dz: 5 },
  timeStep: 3600, // 1 ora
  totalSimulationTime: 365 * 24 * 3600, // 1 anno
  boundaryConditions: [
    { type: "Neumann", value: 0, boundaryName: "top" },
    { type: "Dirichlet", value: 1000000, boundaryName: "bottom" } // Pascal
  ],
  physicsParameters: {
    viscosity: 0.001, // Pa.s
    thermalConductivity: 2.0 // W/(m.K)
  }
};

            

              
                Copy